package cn.edu.scau.cmi.ema.dao;

import cn.edu.scau.cmi.ema.base.CmiPagination;
import cn.edu.scau.cmi.ema.domain.Crawlerdetect;
import cn.edu.scau.cmi.ema.util.CmiSqlUtil;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.EntityManager;
import javax.persistence.NoResultException;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

@Repository("CrawlerdetectDAO")
@Transactional
public class CrawlerdetectDAOImpl extends AbstractJpaDao<Crawlerdetect> implements CrawlerdetectDAO {

	private final static Set<Class<?>> dataTypes = new HashSet<Class<?>>(
			Arrays.asList(new Class<?>[] { Crawlerdetect.class }));

	@PersistenceContext()
	private EntityManager entityManager;

	public CrawlerdetectDAOImpl() {
		super();
	}

	public EntityManager getEntityManager() {
		return entityManager;
	}

	public Set<Class<?>> getTypes() {
		return dataTypes;
	}

	@Transactional
	public Crawlerdetect findCrawlerdetectById(Integer id) throws DataAccessException {

		return findCrawlerdetectById(id, -1, -1);
	}

	@Transactional
	public Crawlerdetect findCrawlerdetectById(Integer id, int startResult, int maxRows) throws DataAccessException {
		try {
			Query query = createNamedQuery("findCrawlerdetectById", startResult, maxRows, id);
			return (Crawlerdetect) query.getSingleResult();
		} catch (NoResultException nre) {
			return null;
		}
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByName(String name) throws DataAccessException {

		return findCrawlerdetectByName(name, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByName(String name, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByName", startResult, maxRows, name);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByNameContaining(String name) throws DataAccessException {

		return findCrawlerdetectByNameContaining(name, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByNameContaining(String name, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByNameContaining", startResult, maxRows, name);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByFilename(String filename) throws DataAccessException {

		return findCrawlerdetectByFilename(filename, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByFilename(String filename, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByFilename", startResult, maxRows, filename);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByFilenameContaining(String filename) throws DataAccessException {

		return findCrawlerdetectByFilenameContaining(filename, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByFilenameContaining(String filename, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByFilenameContaining", startResult, maxRows, filename);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByRownumber(String rownumber) throws DataAccessException {

		return findCrawlerdetectByRownumber(rownumber, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByRownumber(String rownumber, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByRownumber", startResult, maxRows, rownumber);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByRownumberContaining(String rownumber) throws DataAccessException {

		return findCrawlerdetectByRownumberContaining(rownumber, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByRownumberContaining(String rownumber, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByRownumberContaining", startResult, maxRows, rownumber);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByMaxcolumn(String maxcolumn) throws DataAccessException {

		return findCrawlerdetectByMaxcolumn(maxcolumn, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByMaxcolumn(String maxcolumn, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByMaxcolumn", startResult, maxRows, maxcolumn);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByMaxcolumnContaining(String maxcolumn) throws DataAccessException {

		return findCrawlerdetectByMaxcolumnContaining(maxcolumn, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByMaxcolumnContaining(String maxcolumn, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByMaxcolumnContaining", startResult, maxRows, maxcolumn);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByMiscellaneous(String miscellaneous) throws DataAccessException {

		return findCrawlerdetectByMiscellaneous(miscellaneous, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByMiscellaneous(String miscellaneous, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByMiscellaneous", startResult, maxRows, miscellaneous);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByMiscellaneousContaining(String miscellaneous)
			throws DataAccessException {

		return findCrawlerdetectByMiscellaneousContaining(miscellaneous, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByMiscellaneousContaining(String miscellaneous, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByMiscellaneousContaining", startResult, maxRows,
				miscellaneous);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByBrand(String brand) throws DataAccessException {

		return findCrawlerdetectByBrand(brand, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByBrand(String brand, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByBrand", startResult, maxRows, brand);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByBrandContaining(String brand) throws DataAccessException {

		return findCrawlerdetectByBrandContaining(brand, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByBrandContaining(String brand, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByBrandContaining", startResult, maxRows, brand);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByRedetectapplier(String redetectapplier) throws DataAccessException {

		return findCrawlerdetectByRedetectapplier(redetectapplier, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByRedetectapplier(String redetectapplier, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByRedetectapplier", startResult, maxRows, redetectapplier);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByRedetectapplierContaining(String redetectapplier)
			throws DataAccessException {

		return findCrawlerdetectByRedetectapplierContaining(redetectapplier, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByRedetectapplierContaining(String redetectapplier, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByRedetectapplierContaining", startResult, maxRows,
				redetectapplier);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByRedetectresult(String redetectresult) throws DataAccessException {

		return findCrawlerdetectByRedetectresult(redetectresult, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByRedetectresult(String redetectresult, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByRedetectresult", startResult, maxRows, redetectresult);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByRedetectresultContaining(String redetectresult)
			throws DataAccessException {

		return findCrawlerdetectByRedetectresultContaining(redetectresult, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByRedetectresultContaining(String redetectresult, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByRedetectresultContaining", startResult, maxRows,
				redetectresult);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByNumber(String number) throws DataAccessException {

		return findCrawlerdetectByNumber(number, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByNumber(String number, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByNumber", startResult, maxRows, number);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByNumberContaining(String number) throws DataAccessException {

		return findCrawlerdetectByNumberContaining(number, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByNumberContaining(String number, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByNumberContaining", startResult, maxRows, number);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDisagreecontent(String disagreecontent) throws DataAccessException {

		return findCrawlerdetectByDisagreecontent(disagreecontent, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDisagreecontent(String disagreecontent, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDisagreecontent", startResult, maxRows, disagreecontent);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDisagreecontentContaining(String disagreecontent)
			throws DataAccessException {

		return findCrawlerdetectByDisagreecontentContaining(disagreecontent, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDisagreecontentContaining(String disagreecontent, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDisagreecontentContaining", startResult, maxRows,
				disagreecontent);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDisagreedate(String disagreedate) throws DataAccessException {

		return findCrawlerdetectByDisagreedate(disagreedate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDisagreedate(String disagreedate, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDisagreedate", startResult, maxRows, disagreedate);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDisagreedateContaining(String disagreedate)
			throws DataAccessException {

		return findCrawlerdetectByDisagreedateContaining(disagreedate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDisagreedateContaining(String disagreedate, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDisagreedateContaining", startResult, maxRows, disagreedate);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDisagreeconclusion(String disagreeconclusion)
			throws DataAccessException {

		return findCrawlerdetectByDisagreeconclusion(disagreeconclusion, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDisagreeconclusion(String disagreeconclusion, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDisagreeconclusion", startResult, maxRows,
				disagreeconclusion);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDisagreeconclusionContaining(String disagreeconclusion)
			throws DataAccessException {

		return findCrawlerdetectByDisagreeconclusionContaining(disagreeconclusion, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDisagreeconclusionContaining(String disagreeconclusion,
			int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDisagreeconclusionContaining", startResult, maxRows,
				disagreeconclusion);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDisagreeapply(String disagreeapply) throws DataAccessException {

		return findCrawlerdetectByDisagreeapply(disagreeapply, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDisagreeapply(String disagreeapply, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDisagreeapply", startResult, maxRows, disagreeapply);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDisagreeapplyContaining(String disagreeapply)
			throws DataAccessException {

		return findCrawlerdetectByDisagreeapplyContaining(disagreeapply, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDisagreeapplyContaining(String disagreeapply, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDisagreeapplyContaining", startResult, maxRows,
				disagreeapply);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByIsredetectapply(String isredetectapply) throws DataAccessException {

		return findCrawlerdetectByIsredetectapply(isredetectapply, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByIsredetectapply(String isredetectapply, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByIsredetectapply", startResult, maxRows, isredetectapply);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByIsredetectapplyContaining(String isredetectapply)
			throws DataAccessException {

		return findCrawlerdetectByIsredetectapplyContaining(isredetectapply, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByIsredetectapplyContaining(String isredetectapply, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByIsredetectapplyContaining", startResult, maxRows,
				isredetectapply);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectasksource(String detectasksource) throws DataAccessException {

		return findCrawlerdetectByDetectasksource(detectasksource, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectasksource(String detectasksource, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectasksource", startResult, maxRows, detectasksource);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectasksourceContaining(String detectasksource)
			throws DataAccessException {

		return findCrawlerdetectByDetectasksourceContaining(detectasksource, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectasksourceContaining(String detectasksource, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectasksourceContaining", startResult, maxRows,
				detectasksource);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectannounce(String detectannounce) throws DataAccessException {

		return findCrawlerdetectByDetectannounce(detectannounce, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectannounce(String detectannounce, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectannounce", startResult, maxRows, detectannounce);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectannounceContaining(String detectannounce)
			throws DataAccessException {

		return findCrawlerdetectByDetectannounceContaining(detectannounce, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectannounceContaining(String detectannounce, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectannounceContaining", startResult, maxRows,
				detectannounce);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectannouncedate(String detectannouncedate)
			throws DataAccessException {

		return findCrawlerdetectByDetectannouncedate(detectannouncedate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectannouncedate(String detectannouncedate, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectannouncedate", startResult, maxRows,
				detectannouncedate);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectannouncedateContaining(String detectannouncedate)
			throws DataAccessException {

		return findCrawlerdetectByDetectannouncedateContaining(detectannouncedate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectannouncedateContaining(String detectannouncedate,
			int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectannouncedateContaining", startResult, maxRows,
				detectannouncedate);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectdate(String detectdate) throws DataAccessException {

		return findCrawlerdetectByDetectdate(detectdate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectdate(String detectdate, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectdate", startResult, maxRows, detectdate);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectdateContaining(String detectdate) throws DataAccessException {

		return findCrawlerdetectByDetectdateContaining(detectdate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectdateContaining(String detectdate, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectdateContaining", startResult, maxRows, detectdate);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectdepartment(String detectdepartment) throws DataAccessException {

		return findCrawlerdetectByDetectdepartment(detectdepartment, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectdepartment(String detectdepartment, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectdepartment", startResult, maxRows, detectdepartment);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectdepartmentContaining(String detectdepartment)
			throws DataAccessException {

		return findCrawlerdetectByDetectdepartmentContaining(detectdepartment, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectdepartmentContaining(String detectdepartment, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectdepartmentContaining", startResult, maxRows,
				detectdepartment);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectstandard(String detectstandard) throws DataAccessException {

		return findCrawlerdetectByDetectstandard(detectstandard, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectstandard(String detectstandard, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectstandard", startResult, maxRows, detectstandard);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectstandardContaining(String detectstandard)
			throws DataAccessException {

		return findCrawlerdetectByDetectstandardContaining(detectstandard, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectstandardContaining(String detectstandard, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectstandardContaining", startResult, maxRows,
				detectstandard);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectstandardvalue(String detectstandardvalue)
			throws DataAccessException {

		return findCrawlerdetectByDetectstandardvalue(detectstandardvalue, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectstandardvalue(String detectstandardvalue, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectstandardvalue", startResult, maxRows,
				detectstandardvalue);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectstandardvalueContaining(String detectstandardvalue)
			throws DataAccessException {

		return findCrawlerdetectByDetectstandardvalueContaining(detectstandardvalue, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectstandardvalueContaining(String detectstandardvalue,
			int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectstandardvalueContaining", startResult, maxRows,
				detectstandardvalue);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectfeature(String detectfeature) throws DataAccessException {

		return findCrawlerdetectByDetectfeature(detectfeature, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectfeature(String detectfeature, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectfeature", startResult, maxRows, detectfeature);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectfeatureContaining(String detectfeature)
			throws DataAccessException {

		return findCrawlerdetectByDetectfeatureContaining(detectfeature, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectfeatureContaining(String detectfeature, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectfeatureContaining", startResult, maxRows,
				detectfeature);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectlink(String detectlink) throws DataAccessException {

		return findCrawlerdetectByDetectlink(detectlink, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectlink(String detectlink, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectlink", startResult, maxRows, detectlink);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectlinkContaining(String detectlink) throws DataAccessException {

		return findCrawlerdetectByDetectlinkContaining(detectlink, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectlinkContaining(String detectlink, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectlinkContaining", startResult, maxRows, detectlink);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectresult(String detectresult) throws DataAccessException {

		return findCrawlerdetectByDetectresult(detectresult, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectresult(String detectresult, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectresult", startResult, maxRows, detectresult);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectresultContaining(String detectresult)
			throws DataAccessException {

		return findCrawlerdetectByDetectresultContaining(detectresult, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectresultContaining(String detectresult, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectresultContaining", startResult, maxRows, detectresult);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectnumber(String detectnumber) throws DataAccessException {

		return findCrawlerdetectByDetectnumber(detectnumber, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectnumber(String detectnumber, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectnumber", startResult, maxRows, detectnumber);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectnumberContaining(String detectnumber)
			throws DataAccessException {

		return findCrawlerdetectByDetectnumberContaining(detectnumber, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectnumberContaining(String detectnumber, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectnumberContaining", startResult, maxRows, detectnumber);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectdescription(String detectdescription)
			throws DataAccessException {

		return findCrawlerdetectByDetectdescription(detectdescription, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectdescription(String detectdescription, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectdescription", startResult, maxRows, detectdescription);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectdescriptionContaining(String detectdescription)
			throws DataAccessException {

		return findCrawlerdetectByDetectdescriptionContaining(detectdescription, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectdescriptionContaining(String detectdescription, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectdescriptionContaining", startResult, maxRows,
				detectdescription);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectproject(String detectproject) throws DataAccessException {

		return findCrawlerdetectByDetectproject(detectproject, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectproject(String detectproject, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectproject", startResult, maxRows, detectproject);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectprojectContaining(String detectproject)
			throws DataAccessException {

		return findCrawlerdetectByDetectprojectContaining(detectproject, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDetectprojectContaining(String detectproject, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDetectprojectContaining", startResult, maxRows,
				detectproject);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByProducer(String producer) throws DataAccessException {

		return findCrawlerdetectByProducer(producer, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByProducer(String producer, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByProducer", startResult, maxRows, producer);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByProducerContaining(String producer) throws DataAccessException {

		return findCrawlerdetectByProducerContaining(producer, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByProducerContaining(String producer, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByProducerContaining", startResult, maxRows, producer);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByProduceraddress(String produceraddress) throws DataAccessException {

		return findCrawlerdetectByProduceraddress(produceraddress, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByProduceraddress(String produceraddress, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByProduceraddress", startResult, maxRows, produceraddress);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByProduceraddressContaining(String produceraddress)
			throws DataAccessException {

		return findCrawlerdetectByProduceraddressContaining(produceraddress, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByProduceraddressContaining(String produceraddress, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByProduceraddressContaining", startResult, maxRows,
				produceraddress);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByProducedate(String producedate) throws DataAccessException {

		return findCrawlerdetectByProducedate(producedate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByProducedate(String producedate, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByProducedate", startResult, maxRows, producedate);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByProducedateContaining(String producedate) throws DataAccessException {

		return findCrawlerdetectByProducedateContaining(producedate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByProducedateContaining(String producedate, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByProducedateContaining", startResult, maxRows, producedate);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByNetplatform(String netplatform) throws DataAccessException {

		return findCrawlerdetectByNetplatform(netplatform, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByNetplatform(String netplatform, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByNetplatform", startResult, maxRows, netplatform);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByNetplatformContaining(String netplatform) throws DataAccessException {

		return findCrawlerdetectByNetplatformContaining(netplatform, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByNetplatformContaining(String netplatform, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByNetplatformContaining", startResult, maxRows, netplatform);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectBySubject(String subject) throws DataAccessException {

		return findCrawlerdetectBySubject(subject, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectBySubject(String subject, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectBySubject", startResult, maxRows, subject);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectBySubjectContaining(String subject) throws DataAccessException {

		return findCrawlerdetectBySubjectContaining(subject, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectBySubjectContaining(String subject, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectBySubjectContaining", startResult, maxRows, subject);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectBySubjectaddress(String subjectaddress) throws DataAccessException {

		return findCrawlerdetectBySubjectaddress(subjectaddress, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectBySubjectaddress(String subjectaddress, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectBySubjectaddress", startResult, maxRows, subjectaddress);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectBySubjectaddressContaining(String subjectaddress)
			throws DataAccessException {

		return findCrawlerdetectBySubjectaddressContaining(subjectaddress, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectBySubjectaddressContaining(String subjectaddress, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectBySubjectaddressContaining", startResult, maxRows,
				subjectaddress);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByPackagemethod(String packagemethod) throws DataAccessException {

		return findCrawlerdetectByPackagemethod(packagemethod, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByPackagemethod(String packagemethod, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByPackagemethod", startResult, maxRows, packagemethod);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByPackagemethodContaining(String packagemethod)
			throws DataAccessException {

		return findCrawlerdetectByPackagemethodContaining(packagemethod, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByPackagemethodContaining(String packagemethod, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByPackagemethodContaining", startResult, maxRows,
				packagemethod);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByPurchasedate(String purchasedate) throws DataAccessException {

		return findCrawlerdetectByPurchasedate(purchasedate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByPurchasedate(String purchasedate, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByPurchasedate", startResult, maxRows, purchasedate);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByPurchasedateContaining(String purchasedate)
			throws DataAccessException {

		return findCrawlerdetectByPurchasedateContaining(purchasedate, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByPurchasedateContaining(String purchasedate, int startResult,
			int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByPurchasedateContaining", startResult, maxRows, purchasedate);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByFood(String food) throws DataAccessException {

		return findCrawlerdetectByFood(food, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByFood(String food, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByFood", startResult, maxRows, food);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByFoodContaining(String food) throws DataAccessException {

		return findCrawlerdetectByFoodContaining(food, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByFoodContaining(String food, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByFoodContaining", startResult, maxRows, food);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByFoodbatch(String foodbatch) throws DataAccessException {

		return findCrawlerdetectByFoodbatch(foodbatch, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByFoodbatch(String foodbatch, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByFoodbatch", startResult, maxRows, foodbatch);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByFoodbatchContaining(String foodbatch) throws DataAccessException {

		return findCrawlerdetectByFoodbatchContaining(foodbatch, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByFoodbatchContaining(String foodbatch, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByFoodbatchContaining", startResult, maxRows, foodbatch);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByFoodtype(String foodtype) throws DataAccessException {

		return findCrawlerdetectByFoodtype(foodtype, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByFoodtype(String foodtype, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByFoodtype", startResult, maxRows, foodtype);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByFoodtypeContaining(String foodtype) throws DataAccessException {

		return findCrawlerdetectByFoodtypeContaining(foodtype, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByFoodtypeContaining(String foodtype, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByFoodtypeContaining", startResult, maxRows, foodtype);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDescription(String description) throws DataAccessException {

		return findCrawlerdetectByDescription(description, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDescription(String description, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDescription", startResult, maxRows, description);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDescriptionContaining(String description) throws DataAccessException {

		return findCrawlerdetectByDescriptionContaining(description, -1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByDescriptionContaining(String description, int startResult, int maxRows)
			throws DataAccessException {
		Query query = createNamedQuery("findCrawlerdetectByDescriptionContaining", startResult, maxRows, description);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@Transactional
	public Crawlerdetect findCrawlerdetectByPrimaryKey(Integer id) throws DataAccessException {
		return findCrawlerdetectByPrimaryKey(id, -1, -1);
	}

	@Transactional
	public Crawlerdetect findCrawlerdetectByPrimaryKey(Integer id, int startResult, int maxRows)
			throws DataAccessException {
		try {
			Query query = createNamedQuery("findCrawlerdetectByPrimaryKey", startResult, maxRows, id);
			return (Crawlerdetect) query.getSingleResult();
		} catch (NoResultException nre) {
			return null;
		}
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectsByIds(Set<Integer> ids) throws DataAccessException {
		try {
			Query query = createNamedQuery("findCrawlerdetectsByIds", -1, -1, ids);
			return new HashSet(query.getResultList());
		} catch (NoResultException nre) {
			return null;
		}
	}

	@Transactional
	public Set<Crawlerdetect> findAllCrawlerdetects() throws DataAccessException {

		return findAllCrawlerdetects(-1, -1);
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findAllCrawlerdetects(int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findAllCrawlerdetects", startResult, maxRows);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@SuppressWarnings("unchecked")
	public Set<Crawlerdetect> findCrawlerdetectsByCrawlerdetectstatus(Integer crawlerdetectstatusId, int start, int max)
			throws DataAccessException {
		Query query = createNamedQuery("findAllCrawlerdetectsByCrawlerdetectstatus", start, max, crawlerdetectstatusId);
		return new LinkedHashSet<Crawlerdetect>(query.getResultList());
	}

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectByCompositeProperities(String sql, int startResult, int maxRows) {
		return new LinkedHashSet<Crawlerdetect>(createQuery(sql, startResult, maxRows).getResultList());
	}

	@Transactional
	public Set<Crawlerdetect> findCrawlerdetectsByDetachedCriteria(CmiPagination page) throws DataAccessException {
		DetachedCriteria detachedCriteria = CmiSqlUtil.createDetachedCriteria(page, Crawlerdetect.class);
		Session session = (Session) entityManager.getDelegate();
		Set<Crawlerdetect> crawlerdetects = new HashSet(detachedCriteria.getExecutableCriteria(session)
				.setFirstResult(page.getSearchBeginCursor()).setMaxResults(page.getPaginationSize()).list());

		return crawlerdetects;
	}

	@Transactional
	public Crawlerdetect findCrawlerdetectByPhysicalPrimaryKey(String filename, String rownumber)
			throws DataAccessException {
		return findCrawlerdetectByPhysicalPrimaryKey(filename, rownumber, -1, -1);
	}

	@Transactional
	public Crawlerdetect findCrawlerdetectByPhysicalPrimaryKey(String filename, String rownumber, int startResult,
			int maxRows) throws DataAccessException {
		try {
			Query query = createNamedQuery("findCrawlerdetectByPhyscialPrimaryKey", startResult, maxRows, filename,
					rownumber);
			return (Crawlerdetect) query.getSingleResult();
		} catch (NoResultException nre) {
			return null;
		}
	}

	public boolean canBeMerged(Crawlerdetect entity) {
		return true;
	}
}
